#include <gmlib/number/uint256.h>

#include <stdexcept>
#include <cstring>

using namespace number;

void test_uint256_mul_carry_uint32()
{
    uint256_t     multiplier, product;
    std::uint32_t carry;
    std::uint8_t  product_data[32];

    static std::uint8_t  multiplier0[32]  = {0x09,0x99,0x50,0xd8,0x36,0xf6,0x75,0xcc,0x81,0xe7,0x4e,0xf5,0xe8,0xe2,0x5d,0x94,0x0e,0xd9,0x04,0x75,0x95,0x31,0x98,0x5d,0x5d,0x9d,0xc9,0xf8,0x18,0x18,0xe8,0x11};
    static std::uint32_t multiplicand0    = 1862494042;
    static std::uint8_t  product0[32]     = {0xc1,0xca,0xec,0x17,0x89,0xc3,0x83,0x1c,0x48,0xf2,0x94,0x61,0x3e,0x67,0xbd,0x80,0x92,0x28,0x21,0x02,0xac,0x6c,0xa4,0xe9,0x56,0x16,0xe7,0xd4,0x95,0x53,0x6c,0xfa};
    static std::uint32_t carry0           = 69835449;
    uint256_from_bytes(multiplier, multiplier0);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand0);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product0, product_data, 32) != 0 && carry0 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier1[32]  = {0x90,0xc1,0x92,0xcf,0xd3,0xac,0x94,0xaf,0x0f,0x21,0xdd,0xb6,0x6c,0xad,0x4a,0x26,0x8d,0x11,0x6e,0xce,0x17,0x38,0xf7,0xd9,0x3d,0x9c,0x17,0x24,0x11,0xe2,0x0b,0x8f};
    static std::uint32_t multiplicand1    = 4069265501;
    static std::uint8_t  product1[32]     = {0x6f,0x40,0x39,0xa9,0x7b,0x07,0x3e,0xa6,0x4f,0xa8,0x30,0xed,0x4e,0x05,0xf9,0x19,0xc0,0xea,0xaf,0xc4,0xe6,0x3a,0xdd,0x01,0xe3,0xc8,0x1f,0xc4,0x20,0x0b,0x22,0xf3};
    static std::uint32_t carry1           = 2300981221;
    uint256_from_bytes(multiplier, multiplier1);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand1);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product1, product_data, 32) != 0 && carry1 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier2[32]  = {0x65,0x8c,0xda,0x14,0x95,0xe6,0x0a,0xf5,0x93,0xbd,0x04,0xcf,0x0f,0xd6,0x30,0xf1,0xf2,0x9d,0x0d,0xa9,0x95,0x3f,0x48,0xf1,0xa0,0x9f,0x76,0xb5,0xa1,0x70,0xb3,0x38};
    static std::uint32_t multiplicand2    = 4192983756;
    static std::uint8_t  product2[32]     = {0x14,0xa5,0xaa,0xe2,0x44,0xc7,0x53,0xb1,0x81,0x33,0x07,0xb7,0x47,0x71,0x81,0xdc,0x8f,0x9f,0xdb,0x45,0xcd,0x95,0x70,0x2c,0x6c,0xeb,0x14,0xfc,0x9a,0xd4,0x80,0xa0};
    static std::uint32_t carry2           = 1663274805;
    uint256_from_bytes(multiplier, multiplier2);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand2);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product2, product_data, 32) != 0 && carry2 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier3[32]  = {0x8a,0x6a,0x63,0xec,0x24,0xed,0xe6,0xa4,0x6b,0x4c,0xb2,0x42,0x4a,0x23,0xd5,0x96,0x22,0x17,0xbe,0xad,0xdb,0xc4,0x96,0xcb,0x8e,0x81,0x97,0x3e,0x0b,0xec,0xd7,0xb0};
    static std::uint32_t multiplicand3    = 2452055640;
    static std::uint8_t  product3[32]     = {0xde,0x6b,0xbd,0xab,0x63,0xea,0xe1,0x9e,0x67,0xc5,0x6b,0x98,0xec,0xbb,0xf9,0x8e,0x61,0xf5,0x6a,0x46,0xef,0xf1,0x8e,0xc0,0x0c,0x0f,0x9a,0x2b,0xb3,0x2a,0x44,0x80};
    static std::uint32_t carry3           = 1325791879;
    uint256_from_bytes(multiplier, multiplier3);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand3);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product3, product_data, 32) != 0 && carry3 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier4[32]  = {0xa3,0x8f,0xd5,0x47,0x92,0x3a,0x73,0x69,0x94,0xe3,0xbf,0x91,0x1a,0x61,0xdb,0xe2,0x2e,0x44,0x15,0x8b,0xae,0x97,0xba,0x94,0xd0,0xed,0xa8,0x2f,0x8f,0x6d,0x05,0x58};
    static std::uint32_t multiplicand4    = 1599435267;
    static std::uint8_t  product4[32]     = {0x57,0xb0,0x9d,0x31,0x3e,0x63,0x52,0x3f,0x9d,0xf1,0xef,0x89,0xd4,0x54,0xec,0xda,0xd9,0x8f,0xbb,0x00,0xc9,0xcf,0x05,0x1a,0xc5,0xb2,0x3a,0x9b,0xa8,0xe0,0x40,0x08};
    static std::uint32_t carry4           = 1021900735;
    uint256_from_bytes(multiplier, multiplier4);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand4);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product4, product_data, 32) != 0 && carry4 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier5[32]  = {0x74,0x03,0xe4,0x30,0xec,0x66,0xa7,0x87,0x95,0xe7,0x61,0xd1,0x77,0x31,0xaf,0x10,0x50,0x6b,0xf2,0xef,0xc6,0xf8,0x77,0x18,0x6d,0x76,0xb0,0x7e,0x88,0x1e,0xd1,0x62};
    static std::uint32_t multiplicand5    = 1287489453;
    static std::uint8_t  product5[32]     = {0x72,0x44,0x03,0x3f,0xd3,0x52,0x13,0x8a,0xb8,0xfa,0x50,0x0f,0xd6,0xd0,0x54,0x40,0xd0,0x27,0x46,0xc1,0xaa,0x3e,0x6a,0x41,0x6e,0x1b,0xa4,0x33,0xea,0x98,0x2d,0x3a};
    static std::uint32_t carry5           = 583470106;
    uint256_from_bytes(multiplier, multiplier5);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand5);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product5, product_data, 32) != 0 && carry5 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier6[32]  = {0xfa,0xec,0xbd,0x38,0x9b,0xe4,0xbc,0xfc,0x49,0xb6,0x4a,0x08,0x72,0xe6,0xcc,0x3a,0xba,0xbc,0xed,0x20,0x57,0xee,0x05,0xcd,0xe0,0x09,0x02,0xc7,0x7e,0xbf,0xf2,0x06};
    static std::uint32_t multiplicand6    = 1795823848;
    static std::uint8_t  product6[32]     = {0xa5,0xa7,0x7b,0xd7,0x8d,0xac,0xfd,0x9c,0x50,0x7e,0xd6,0xce,0x4a,0xa6,0xd9,0x38,0xb9,0x75,0xd9,0x47,0x46,0xef,0x14,0x17,0x5e,0x32,0x66,0x54,0xd2,0xdf,0xe5,0x70};
    static std::uint32_t carry6           = 1760221375;
    uint256_from_bytes(multiplier, multiplier6);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand6);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product6, product_data, 32) != 0 && carry6 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier7[32]  = {0x50,0x51,0xc1,0xcc,0xd1,0x7f,0x9a,0xca,0xe0,0x1f,0x50,0x57,0xca,0x02,0x13,0x5e,0x92,0xb1,0xd3,0xf2,0x8e,0xde,0x0d,0x7a,0xc3,0xba,0xea,0x9e,0x13,0xde,0xef,0x86};
    static std::uint32_t multiplicand7    = 2986270863;
    static std::uint8_t  product7[32]     = {0x4d,0x4f,0x8f,0x5a,0x87,0xf9,0x01,0x0d,0x01,0x90,0x8f,0x3f,0x43,0x5e,0x12,0x2a,0x8a,0x3a,0xe9,0x23,0x5a,0xf7,0x62,0x82,0xf7,0x48,0x3a,0x7d,0x78,0x11,0x0b,0xda};
    static std::uint32_t carry7           = 936935057;
    uint256_from_bytes(multiplier, multiplier7);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand7);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product7, product_data, 32) != 0 && carry7 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier8[32]  = {0xb3,0x94,0xfb,0x36,0xbb,0x2d,0x42,0x0f,0x0f,0x88,0x08,0x0b,0x10,0xa3,0xd6,0xb2,0xaa,0x05,0xe1,0x1a,0xb2,0x71,0x59,0x45,0x79,0x5e,0x82,0x29,0x45,0x1a,0xbd,0x81};
    static std::uint32_t multiplicand8    = 3530140069;
    static std::uint8_t  product8[32]     = {0x07,0xda,0xf1,0x97,0xf7,0xb2,0x7a,0x5a,0x30,0x2c,0xb6,0x6f,0x81,0x15,0xe2,0x76,0xb1,0xb8,0xe1,0xba,0x72,0x0b,0xb5,0x6f,0xdb,0x74,0x6a,0xa3,0xbd,0x3f,0x4d,0x25};
    static std::uint32_t carry8           = 2476365103;
    uint256_from_bytes(multiplier, multiplier8);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand8);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product8, product_data, 32) != 0 && carry8 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier9[32]  = {0xf0,0xce,0x58,0x35,0x05,0xc6,0xaf,0x07,0x58,0xd5,0x56,0x3d,0xab,0x2c,0xd3,0x1e,0xe3,0x15,0x12,0x88,0x62,0xc3,0x3a,0x4f,0xb7,0x74,0xeb,0x52,0x48,0xdb,0x40,0xaf};
    static std::uint32_t multiplicand9    = 1526706729;
    static std::uint8_t  product9[32]     = {0x8b,0x39,0x98,0xf3,0x00,0x11,0xa0,0xc4,0x25,0xbc,0xf4,0xc4,0xbc,0x92,0xe4,0x58,0x6d,0xd5,0xcf,0x7a,0xab,0xb6,0x9c,0x85,0x01,0xec,0x8d,0xf9,0x12,0x68,0x0a,0x07};
    static std::uint32_t carry9           = 1436094498;
    uint256_from_bytes(multiplier, multiplier9);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand9);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product9, product_data, 32) != 0 && carry9 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier10[32]  = {0x2a,0x96,0xfb,0x1a,0x14,0xa0,0xf9,0xe7,0x7f,0x1b,0x10,0x3c,0xdf,0x15,0x82,0xb0,0xea,0xb4,0x77,0xd2,0x64,0x15,0x47,0x9c,0x65,0xdc,0x9f,0x50,0x3f,0x63,0xaf,0x83};
    static std::uint32_t multiplicand10    = 2363175007;
    static std::uint8_t  product10[32]     = {0x2f,0xb3,0xc0,0xec,0x39,0x24,0xad,0xc5,0x6c,0x29,0x0b,0x4a,0x5f,0x30,0x25,0x92,0x7f,0x27,0x2b,0x34,0xeb,0xd2,0xb0,0xff,0x57,0x0e,0xe8,0xec,0xff,0xf7,0xb1,0x9d};
    static std::uint32_t carry10           = 393152647;
    uint256_from_bytes(multiplier, multiplier10);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand10);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product10, product_data, 32) != 0 && carry10 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier11[32]  = {0xf5,0x2d,0xdf,0x5d,0x61,0x64,0x99,0xc9,0xe2,0x5a,0x76,0x05,0xae,0xc6,0xf0,0x24,0x5b,0xd8,0x6d,0x40,0xfc,0x89,0x1b,0x4a,0x6a,0x50,0xdf,0x4d,0xb4,0xd6,0x6a,0x3a};
    static std::uint32_t multiplicand11    = 648200381;
    static std::uint8_t  product11[32]     = {0x9f,0xf0,0x81,0x79,0xa3,0xf7,0x9e,0x93,0x7c,0xd7,0x86,0xd0,0x99,0x9e,0xce,0xe6,0xe9,0x55,0x8f,0x31,0x96,0x90,0x3d,0xff,0xfd,0x33,0x67,0x73,0x26,0xab,0xec,0xd2};
    static std::uint32_t carry11           = 620801734;
    uint256_from_bytes(multiplier, multiplier11);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand11);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product11, product_data, 32) != 0 && carry11 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier12[32]  = {0x64,0xe5,0x0c,0xad,0x66,0x23,0x7a,0x04,0x65,0xe7,0xe4,0x23,0x64,0x72,0xf1,0xa3,0x8f,0x2c,0x6e,0xc8,0xcc,0x41,0x69,0xa3,0xae,0x3a,0x2b,0x7f,0xdf,0xe0,0x18,0x93};
    static std::uint32_t multiplicand12    = 1719888006;
    static std::uint8_t  product12[32]     = {0x70,0x78,0x7b,0x07,0x10,0xfe,0x32,0x43,0x64,0x31,0xfe,0x6e,0x18,0x12,0xe5,0xa7,0xb0,0x66,0x25,0xa5,0xc3,0x55,0x1f,0x8e,0x09,0xc1,0x91,0x59,0x5e,0x81,0x94,0xf2};
    static std::uint32_t carry12           = 677842292;
    uint256_from_bytes(multiplier, multiplier12);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand12);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product12, product_data, 32) != 0 && carry12 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier13[32]  = {0xf2,0xee,0x4e,0x45,0x19,0xf9,0x91,0x9c,0x89,0x5f,0xd7,0xb3,0x26,0xb9,0x4c,0x7f,0x91,0x18,0xbb,0x16,0x00,0x0f,0x49,0xc8,0x1a,0x35,0x8c,0xa0,0x0d,0x75,0x98,0x5d};
    static std::uint32_t multiplicand13    = 2635981472;
    static std::uint8_t  product13[32]     = {0x74,0xcb,0xeb,0xb1,0x0d,0x82,0x8a,0x40,0xc6,0x5d,0xff,0x0f,0xaf,0xc8,0x08,0x5c,0x34,0x25,0xbb,0xc8,0x9c,0x6e,0x93,0x82,0xbd,0xff,0xd4,0xad,0x85,0x8a,0x54,0x20};
    static std::uint32_t carry13           = 2501411341;
    uint256_from_bytes(multiplier, multiplier13);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand13);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product13, product_data, 32) != 0 && carry13 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier14[32]  = {0x84,0x2e,0x7f,0xc2,0x29,0x54,0x0a,0x6e,0xb1,0x2a,0xa1,0xf6,0xd4,0x2f,0xdd,0xbb,0x7a,0x86,0xf7,0xa2,0x43,0xc7,0x1b,0x9a,0xbd,0x87,0xa8,0x65,0x57,0xb6,0xfb,0x7e};
    static std::uint32_t multiplicand14    = 1553714997;
    static std::uint8_t  product14[32]     = {0x18,0x57,0xac,0x3f,0x9b,0x86,0x41,0x30,0xeb,0x7d,0xca,0x57,0x42,0xbf,0x30,0x99,0xbf,0xc8,0x10,0xdf,0x5a,0x58,0x57,0xf1,0x4f,0x21,0xad,0x13,0xab,0x86,0xf3,0x16};
    static std::uint32_t carry14           = 802236686;
    uint256_from_bytes(multiplier, multiplier14);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand14);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product14, product_data, 32) != 0 && carry14 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier15[32]  = {0xe8,0x83,0xa1,0xd4,0x5d,0xe0,0x09,0x97,0x84,0xb5,0xa8,0x18,0x42,0xd8,0x72,0x08,0xd8,0x6f,0x40,0xf6,0xb2,0x39,0xf3,0xc7,0x17,0x4c,0x77,0xa2,0xdd,0x02,0xde,0x92};
    static std::uint32_t multiplicand15    = 2159067275;
    static std::uint8_t  product15[32]     = {0x69,0xc8,0xb3,0x89,0x5a,0x5c,0xe9,0xbc,0xfe,0xce,0xa5,0x21,0x73,0x58,0xfa,0x18,0xf7,0xd8,0xcd,0x59,0x60,0xd2,0xee,0xf6,0xae,0xb8,0x7c,0x72,0x2b,0xdc,0x59,0x46};
    static std::uint32_t carry15           = 1960991306;
    uint256_from_bytes(multiplier, multiplier15);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand15);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product15, product_data, 32) != 0 && carry15 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier16[32]  = {0xda,0x45,0xe1,0x8a,0xc2,0x21,0x6b,0x02,0xfc,0x24,0x1d,0x0b,0xc9,0xd4,0x88,0xb1,0xcf,0xbf,0x33,0x60,0x9c,0xfc,0x86,0x52,0x39,0x19,0x42,0x42,0xa2,0xed,0xdb,0xbd};
    static std::uint32_t multiplicand16    = 3462081170;
    static std::uint8_t  product16[32]     = {0xc7,0x65,0x4a,0xf9,0xa3,0x92,0x35,0x47,0x88,0xf6,0x44,0x61,0xa6,0x03,0xd5,0xcc,0xdb,0x24,0x28,0xb4,0xdf,0x3a,0xb7,0x8e,0xe2,0x12,0x0a,0x1b,0x23,0xe3,0x53,0xca};
    static std::uint32_t carry16           = 2951870112;
    uint256_from_bytes(multiplier, multiplier16);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand16);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product16, product_data, 32) != 0 && carry16 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier17[32]  = {0x7e,0x26,0xf3,0x6a,0x84,0x83,0xf8,0xb8,0x33,0x2d,0xd3,0x31,0x3a,0x0b,0x99,0x65,0xcd,0xa6,0xc6,0xfd,0xbd,0x68,0x51,0x67,0x66,0x93,0x40,0x36,0xd1,0x7e,0x44,0x97};
    static std::uint32_t multiplicand17    = 3139638261;
    static std::uint8_t  product17[32]     = {0xb5,0xb4,0x61,0x80,0x2c,0x54,0x2c,0x9e,0x36,0xa9,0x2e,0x0e,0xbf,0xa0,0x4d,0xd9,0xbf,0x6d,0x5e,0x9e,0xab,0xf1,0x2a,0x9b,0xeb,0x36,0x66,0x60,0x8a,0x93,0xd9,0x83};
    static std::uint32_t carry17           = 1547156727;
    uint256_from_bytes(multiplier, multiplier17);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand17);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product17, product_data, 32) != 0 && carry17 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier18[32]  = {0x32,0x5b,0x55,0xdd,0x78,0x57,0x29,0x76,0x3a,0x12,0x91,0x7c,0x1a,0x26,0xf8,0x89,0x38,0x70,0x38,0x00,0x14,0x9e,0x25,0x9b,0x5d,0x58,0xc7,0x05,0xf9,0x79,0xd0,0x4a};
    static std::uint32_t multiplicand18    = 877776915;
    static std::uint8_t  product18[32]     = {0x1a,0x10,0x19,0x36,0xe2,0x5c,0x48,0x62,0xa3,0x29,0xd2,0x46,0x1d,0xb5,0x96,0xec,0x1a,0x0a,0xde,0x6f,0x7b,0x69,0x97,0xe4,0x3e,0xdc,0x4d,0xfe,0x6c,0xb0,0x95,0x7e};
    static std::uint32_t carry18           = 172664133;
    uint256_from_bytes(multiplier, multiplier18);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand18);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product18, product_data, 32) != 0 && carry18 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier19[32]  = {0xe8,0xe7,0x27,0x89,0x1e,0xb2,0x01,0x09,0xa9,0x1c,0x24,0x39,0xd5,0xab,0x8b,0x4d,0x15,0xb4,0x0a,0xeb,0xa4,0xa4,0x5e,0xff,0xcc,0xb5,0x73,0xd9,0x58,0x10,0xd6,0x0e};
    static std::uint32_t multiplicand19    = 3221828754;
    static std::uint8_t  product19[32]     = {0x02,0xb3,0xfb,0x78,0xf1,0xe6,0x9b,0x04,0xcf,0xb1,0x93,0xe4,0x6a,0x1d,0xe5,0xe4,0x10,0xaa,0x28,0xdc,0x79,0x90,0x6c,0xbb,0xaf,0xb4,0xf0,0xf9,0xab,0x92,0xeb,0xfc};
    static std::uint32_t carry19           = 2931146139;
    uint256_from_bytes(multiplier, multiplier19);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand19);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product19, product_data, 32) != 0 && carry19 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier20[32]  = {0xf2,0x61,0x49,0xed,0xbe,0x4c,0x5c,0xe6,0x66,0xc1,0x49,0x4e,0x76,0x91,0xb0,0x6f,0x65,0x55,0xab,0xfe,0xb8,0xc9,0x81,0x7a,0xf8,0xbe,0x88,0x31,0xf2,0x37,0xe4,0x5a};
    static std::uint32_t multiplicand20    = 3112986562;
    static std::uint8_t  product20[32]     = {0x0f,0x01,0xee,0xa0,0x3d,0x80,0xf9,0x9f,0x6d,0x90,0x3f,0x57,0x75,0x8a,0xda,0x55,0x65,0xf6,0x80,0x25,0xc8,0xce,0x51,0xe3,0xbc,0x8a,0x28,0xe3,0xf6,0x73,0x42,0x34};
    static std::uint32_t carry20           = 2947366366;
    uint256_from_bytes(multiplier, multiplier20);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand20);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product20, product_data, 32) != 0 && carry20 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier21[32]  = {0x36,0x78,0xbc,0x8d,0x40,0x78,0x3f,0x0a,0x07,0x2a,0x98,0xd2,0x36,0x06,0xde,0xfc,0xdf,0xb8,0x5c,0x0d,0xd3,0x7e,0xe9,0x15,0x31,0xde,0xc4,0xf4,0xdf,0x2a,0x8b,0x79};
    static std::uint32_t multiplicand21    = 2152474070;
    static std::uint8_t  product21[32]     = {0x96,0x59,0x4b,0x9d,0x00,0x30,0x92,0x79,0x9f,0x1d,0x9b,0x10,0xca,0xe7,0x8c,0x7a,0xe7,0x45,0x31,0x57,0xef,0x01,0x18,0x89,0xca,0xf7,0x8f,0x51,0x9b,0xa5,0x14,0x26};
    static std::uint32_t carry21           = 458002987;
    uint256_from_bytes(multiplier, multiplier21);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand21);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product21, product_data, 32) != 0 && carry21 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier22[32]  = {0x21,0x8e,0x0b,0x7b,0xd5,0x8d,0xcd,0xb4,0x6b,0x44,0x68,0x06,0x8b,0x5a,0xb3,0xee,0x42,0x65,0xbb,0x31,0x53,0x74,0x09,0x02,0x96,0x20,0xbf,0x0d,0xc3,0x80,0x84,0xa0};
    static std::uint32_t multiplicand22    = 2154565813;
    static std::uint8_t  product22[32]     = {0x5d,0x2a,0xda,0x93,0xd7,0xdd,0x2c,0x23,0x46,0x4e,0x19,0x91,0x3c,0x16,0xfc,0x1e,0xf0,0x29,0xa8,0x8c,0x59,0xc2,0x3d,0x8d,0xac,0xa6,0xad,0x7b,0x35,0xa7,0xc5,0x20};
    static std::uint32_t carry22           = 282406875;
    uint256_from_bytes(multiplier, multiplier22);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand22);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product22, product_data, 32) != 0 && carry22 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier23[32]  = {0xc6,0xc9,0x1b,0x92,0x70,0xac,0x06,0xac,0xdf,0x70,0x30,0x17,0x04,0xc9,0xd7,0x8d,0x82,0xb3,0x35,0x99,0x86,0x04,0x87,0x19,0x26,0xde,0xbf,0xdb,0x88,0x25,0xae,0x56};
    static std::uint32_t multiplicand23    = 2613722295;
    static std::uint8_t  product23[32]     = {0xa7,0xfe,0x17,0xde,0xcc,0x3a,0x85,0x95,0xe6,0x87,0xc2,0x5a,0x7e,0x99,0xe3,0xa6,0xad,0xf3,0xc9,0x86,0xb1,0x48,0x02,0x04,0x4c,0xda,0xd8,0x20,0xc9,0xa7,0xc7,0x7a};
    static std::uint32_t carry23           = 2029571462;
    uint256_from_bytes(multiplier, multiplier23);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand23);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product23, product_data, 32) != 0 && carry23 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier24[32]  = {0xb9,0xa6,0x44,0x2e,0x9e,0x7d,0x6b,0x37,0x79,0x36,0xd5,0x36,0x24,0x3d,0x35,0x70,0x2c,0x1e,0xea,0x1f,0x26,0x59,0x74,0xa7,0xcc,0x96,0x6f,0x46,0xc6,0xaa,0x7d,0x55};
    static std::uint32_t multiplicand24    = 2390044639;
    static std::uint8_t  product24[32]     = {0x43,0x91,0xf4,0x7f,0xdb,0x86,0x64,0xe7,0x21,0xc1,0x2e,0x6e,0x72,0xde,0x74,0xce,0x63,0x6b,0xce,0xc4,0x38,0x83,0x5f,0x34,0xf3,0x04,0x4a,0x90,0xc9,0x5e,0xc8,0x0b};
    static std::uint32_t carry24           = 1733244294;
    uint256_from_bytes(multiplier, multiplier24);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand24);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product24, product_data, 32) != 0 && carry24 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier25[32]  = {0xc6,0xc8,0x0e,0x2b,0xc8,0xc6,0x14,0xb2,0x7b,0x84,0x44,0xd1,0x8e,0x31,0x70,0x41,0x87,0xdd,0xae,0xb7,0x84,0xb2,0x80,0x54,0xae,0xad,0x44,0xb0,0x53,0x73,0x90,0xe5};
    static std::uint32_t multiplicand25    = 244051092;
    static std::uint8_t  product25[32]     = {0x6f,0x79,0x67,0x15,0xad,0x42,0xcd,0xa2,0x2b,0x77,0xe1,0x37,0x51,0x14,0x34,0x0e,0xd0,0x21,0x00,0x5d,0x95,0x08,0x93,0xd2,0xa7,0xcb,0xe4,0x8a,0xfa,0xb9,0xe0,0x64};
    static std::uint32_t carry25           = 189503257;
    uint256_from_bytes(multiplier, multiplier25);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand25);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product25, product_data, 32) != 0 && carry25 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier26[32]  = {0x8f,0xcd,0x7f,0x40,0x73,0xc1,0xcd,0x2c,0x81,0xf9,0x8b,0x52,0x19,0x05,0xd5,0x91,0xc5,0xb2,0xe7,0x5a,0x0a,0xcd,0x8b,0xe1,0x46,0xe4,0x09,0x90,0x30,0xf9,0x70,0x58};
    static std::uint32_t multiplicand26    = 3919106286;
    static std::uint8_t  product26[32]     = {0xe0,0x10,0xca,0xc8,0x69,0x9a,0x34,0xf4,0x08,0xb7,0x65,0x80,0x7c,0x70,0x34,0xf1,0x79,0x97,0xbc,0xd8,0x24,0x06,0xb9,0x23,0x19,0xf6,0x27,0x32,0xff,0x6d,0xf1,0xd0};
    static std::uint32_t carry26           = 2201477169;
    uint256_from_bytes(multiplier, multiplier26);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand26);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product26, product_data, 32) != 0 && carry26 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier27[32]  = {0xf1,0x06,0x37,0xce,0x81,0xfc,0x06,0x9e,0x7a,0x60,0x96,0x83,0xce,0xaf,0x49,0x15,0x88,0x85,0x64,0xe8,0x82,0x16,0x85,0x8f,0x73,0xcc,0xef,0x03,0x46,0xf5,0xa1,0xb4};
    static std::uint32_t multiplicand27    = 4051301074;
    static std::uint8_t  product27[32]     = {0x60,0xd4,0xb0,0xa1,0x31,0x1c,0x03,0x08,0xeb,0x63,0xc6,0x28,0x0f,0x93,0x69,0xc3,0xab,0x2d,0x42,0x15,0x2d,0x8c,0xd4,0x03,0xc6,0x66,0xf1,0x18,0x4a,0x6e,0xcd,0xa8};
    static std::uint32_t carry27           = 3814304535;
    uint256_from_bytes(multiplier, multiplier27);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand27);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product27, product_data, 32) != 0 && carry27 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier28[32]  = {0x50,0xe4,0x0d,0x54,0x71,0x2e,0xa6,0xb3,0x64,0x71,0xfd,0xe4,0x1f,0x22,0x9d,0xd0,0x6a,0xa8,0xb9,0xe0,0x23,0x1b,0x3e,0x14,0x72,0x91,0x35,0xbd,0xd7,0x0a,0x39,0xd1};
    static std::uint32_t multiplicand28    = 2882590715;
    static std::uint8_t  product28[32]     = {0x13,0x01,0x1c,0x1a,0x6c,0x97,0xdc,0x74,0xe2,0x23,0xf0,0x5b,0x0a,0x10,0x22,0x2c,0x05,0x19,0x34,0xd8,0x65,0xfd,0x1f,0x25,0xc1,0x64,0xad,0xa9,0x02,0x65,0x36,0xeb};
    static std::uint32_t carry28           = 910840433;
    uint256_from_bytes(multiplier, multiplier28);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand28);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product28, product_data, 32) != 0 && carry28 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier29[32]  = {0xb4,0xd1,0x9e,0xc1,0x29,0x55,0xd6,0xf0,0x39,0x45,0x33,0x6b,0xd5,0x1b,0x18,0x15,0xaa,0xf7,0x19,0xf3,0xfd,0x68,0x37,0x3b,0x29,0xac,0xf1,0xa5,0x7c,0xbd,0x1f,0x5a};
    static std::uint32_t multiplicand29    = 1734349671;
    static std::uint8_t  product29[32]     = {0x8f,0x30,0x3f,0x74,0x41,0x9d,0xa0,0x8a,0xd8,0xd6,0x82,0x0d,0x80,0x99,0xd4,0x83,0x06,0xcc,0x82,0x47,0x34,0xfb,0xd2,0xf9,0xcd,0xc3,0x60,0x60,0x31,0x2b,0x4b,0x36};
    static std::uint32_t carry29           = 1225012015;
    uint256_from_bytes(multiplier, multiplier29);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand29);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product29, product_data, 32) != 0 && carry29 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier30[32]  = {0x04,0xfc,0xd5,0x55,0x5d,0xaf,0x10,0x6d,0xb8,0xde,0xe0,0x81,0x17,0x9a,0x07,0x1e,0x51,0x8a,0xe4,0x52,0x5b,0x4b,0x1b,0x75,0x32,0x1c,0x52,0x96,0x6b,0xd8,0xc6,0x76};
    static std::uint32_t multiplicand30    = 2379627705;
    static std::uint8_t  product30[32]     = {0x36,0xab,0xe9,0x09,0xe5,0xe7,0xe2,0x95,0x9b,0x98,0x0f,0x7f,0xce,0x3b,0xe9,0xe1,0xb4,0x02,0xfb,0xd2,0x14,0x47,0xcc,0x99,0xbc,0xf7,0x7c,0x7f,0xa2,0xcf,0x13,0x46};
    static std::uint32_t carry30           = 46362121;
    uint256_from_bytes(multiplier, multiplier30);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand30);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product30, product_data, 32) != 0 && carry30 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier31[32]  = {0x2e,0x7a,0x26,0xe9,0xc7,0x6c,0x60,0x3f,0xe7,0xe8,0xf9,0xf6,0x0a,0x22,0x73,0x85,0x45,0x9c,0x94,0x5c,0x43,0xfc,0x05,0x27,0x15,0x85,0x0a,0x03,0x1a,0xd2,0xd5,0xf1};
    static std::uint32_t multiplicand31    = 3246035554;
    static std::uint8_t  product31[32]     = {0x3f,0xb5,0xf7,0x70,0x32,0xac,0x74,0x33,0x42,0xa2,0xcf,0x7a,0x0e,0x10,0x73,0x30,0x35,0xc6,0xd0,0x14,0xad,0x43,0xd1,0x2f,0x39,0x57,0x56,0x41,0x28,0x93,0x58,0x42};
    static std::uint32_t carry31           = 589322272;
    uint256_from_bytes(multiplier, multiplier31);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand31);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product31, product_data, 32) != 0 && carry31 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier32[32]  = {0x42,0x34,0x33,0x54,0xf2,0x2d,0x28,0x82,0xd1,0xa8,0x9b,0x37,0xad,0x0c,0x9b,0xb6,0xe9,0x52,0x6a,0x69,0xd9,0x7e,0x96,0x7b,0x6c,0x18,0xd9,0x82,0xd1,0xdc,0xec,0x53};
    static std::uint32_t multiplicand32    = 2450686540;
    static std::uint8_t  product32[32]     = {0x37,0xa7,0x28,0x7a,0x48,0xbf,0x5b,0xae,0x87,0x7b,0xb6,0x19,0x0a,0xbe,0x85,0x44,0xf7,0xfc,0xd4,0x97,0xd2,0x53,0x1f,0x54,0x9c,0xb7,0xc1,0xb8,0x71,0x6e,0x4e,0xa4};
    static std::uint32_t carry32           = 633769636;
    uint256_from_bytes(multiplier, multiplier32);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand32);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product32, product_data, 32) != 0 && carry32 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier33[32]  = {0x2e,0xef,0xa2,0x79,0xb0,0x2e,0x3d,0x8d,0xcc,0xb1,0xc5,0x1d,0x0e,0xba,0x0e,0xa8,0x47,0x70,0xa0,0x87,0x16,0xe6,0xfe,0xc3,0x53,0xb9,0x73,0x77,0xb3,0x4e,0x8e,0xce};
    static std::uint32_t multiplicand33    = 3845220704;
    static std::uint8_t  product33[32]     = {0xd7,0x64,0xec,0xce,0xa8,0xd5,0x71,0x7b,0x65,0x3f,0x16,0xa9,0x2b,0xe5,0xf0,0x8f,0x8d,0x6b,0x9f,0x28,0xd2,0x65,0x91,0x5f,0xa3,0x35,0xfd,0x36,0x11,0x76,0x0b,0x40};
    static std::uint32_t carry33           = 704998278;
    uint256_from_bytes(multiplier, multiplier33);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand33);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product33, product_data, 32) != 0 && carry33 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier34[32]  = {0x02,0xf4,0xb3,0x42,0x74,0x2a,0x80,0x63,0x1f,0x26,0x42,0xaa,0xdc,0xde,0xd2,0x04,0x43,0xb3,0x0f,0x66,0x11,0x0e,0x2c,0xb6,0x38,0xef,0xba,0xeb,0xdb,0x31,0xcc,0xd2};
    static std::uint32_t multiplicand34    = 3931727770;
    static std::uint8_t  product34[32]     = {0x4b,0x9c,0xce,0xd8,0x38,0x27,0xea,0x66,0x7d,0x21,0x4f,0x15,0x6d,0xe7,0x43,0x21,0x6a,0xfc,0x37,0x0f,0x11,0xe9,0x22,0xba,0x46,0xc6,0x10,0x9b,0x0e,0x5f,0xb4,0x54};
    static std::uint32_t carry34           = 45397023;
    uint256_from_bytes(multiplier, multiplier34);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand34);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product34, product_data, 32) != 0 && carry34 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier35[32]  = {0xa0,0xf0,0x96,0xda,0x4f,0xde,0xbb,0xec,0xee,0xa7,0xbb,0x64,0x33,0xa7,0x15,0x68,0x2e,0x5f,0x95,0x0c,0x0c,0xe5,0xaf,0x69,0x43,0x0b,0x91,0xed,0x29,0x54,0xba,0x5c};
    static std::uint32_t multiplicand35    = 884211552;
    static std::uint8_t  product35[32]     = {0xd3,0x5b,0x1e,0x56,0x57,0xdc,0x6b,0xea,0xf4,0x1d,0x23,0x33,0xee,0x3e,0xa4,0x5e,0x43,0x5a,0x91,0x98,0xa8,0x13,0xdb,0xfc,0xdf,0xeb,0x11,0x33,0xe3,0xbb,0x86,0x80};
    static std::uint32_t carry35           = 555878249;
    uint256_from_bytes(multiplier, multiplier35);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand35);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product35, product_data, 32) != 0 && carry35 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier36[32]  = {0xfa,0x61,0x97,0x74,0x8d,0x11,0x8e,0x37,0x81,0x72,0x8a,0x07,0xbb,0xab,0x27,0xf6,0x04,0xb8,0x15,0x7d,0x03,0xed,0xb9,0x20,0x09,0x75,0x83,0x40,0x40,0x1d,0x68,0xfb};
    static std::uint32_t multiplicand36    = 2208622121;
    static std::uint8_t  product36[32]     = {0x72,0x8e,0x53,0x6d,0xe0,0x62,0x2f,0x33,0x05,0x57,0xdc,0xf1,0x52,0x55,0xa7,0x90,0xe1,0xe2,0xec,0x93,0x32,0xc2,0xa0,0x13,0x0d,0xb5,0xde,0x74,0x62,0xd3,0x52,0x33};
    static std::uint32_t carry36           = 2160146465;
    uint256_from_bytes(multiplier, multiplier36);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand36);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product36, product_data, 32) != 0 && carry36 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier37[32]  = {0xd6,0x44,0xde,0x2f,0x0d,0xec,0x68,0x23,0xfb,0x5c,0x9d,0x56,0x58,0xf9,0x2d,0xea,0xfd,0x4b,0xd0,0x30,0x67,0x9a,0x44,0xdd,0x23,0xc4,0x9c,0xae,0xa2,0xcf,0x62,0xba};
    static std::uint32_t multiplicand37    = 61225318;
    static std::uint8_t  product37[32]     = {0x54,0x95,0xcd,0x5d,0x22,0xa8,0x95,0x33,0xce,0xf7,0x87,0x54,0x75,0xd9,0xc0,0xa0,0x5e,0x29,0xb7,0x31,0xdf,0x9d,0x2c,0x66,0xac,0x5f,0x50,0x77,0x3e,0x38,0xc0,0x1c};
    static std::uint32_t carry37           = 51244877;
    uint256_from_bytes(multiplier, multiplier37);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand37);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product37, product_data, 32) != 0 && carry37 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier38[32]  = {0x99,0x49,0x8a,0xc4,0x48,0x2c,0xc7,0x8e,0xf8,0x8e,0xde,0x10,0xab,0xa8,0xb9,0xb3,0x81,0x85,0x79,0x7c,0xde,0xdb,0x91,0x09,0x61,0x81,0x77,0xff,0xd7,0x5d,0x67,0x69};
    static std::uint32_t multiplicand38    = 2975061660;
    static std::uint8_t  product38[32]     = {0x96,0x5b,0x00,0x6f,0xf7,0x50,0x7c,0xc2,0x6a,0xc8,0x91,0xc0,0xf7,0xcd,0x7e,0xee,0x3a,0x76,0x7a,0xda,0xdb,0x7f,0x5a,0x2b,0x71,0x0f,0x65,0xb7,0x71,0x67,0xc9,0xfc};
    static std::uint32_t carry38           = 1781402698;
    uint256_from_bytes(multiplier, multiplier38);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand38);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product38, product_data, 32) != 0 && carry38 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier39[32]  = {0x43,0x63,0xe5,0xd9,0x00,0xed,0x6b,0x02,0x72,0x21,0x8f,0xdc,0x44,0xdf,0x96,0xff,0x28,0x54,0x14,0x24,0x2f,0x73,0x3b,0x05,0x75,0x9e,0xb5,0x59,0x0b,0x94,0xaf,0x3a};
    static std::uint32_t multiplicand39    = 4130841704;
    static std::uint8_t  product39[32]     = {0x48,0x57,0xbc,0x96,0xd0,0x33,0xcf,0x8f,0x70,0x4d,0x34,0xbd,0xd9,0x23,0x42,0xe9,0x58,0x6e,0x49,0x92,0x05,0xd2,0x40,0xed,0xfb,0xe9,0x14,0xeb,0x56,0x1e,0x57,0x90};
    static std::uint32_t carry39           = 1087415452;
    uint256_from_bytes(multiplier, multiplier39);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand39);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product39, product_data, 32) != 0 && carry39 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier40[32]  = {0xe1,0xe4,0x37,0xb7,0xf7,0x35,0xef,0xe6,0x08,0xd1,0x80,0x11,0x3e,0x94,0x0b,0xb4,0x52,0xd3,0x1e,0x1b,0x8c,0x0d,0x00,0x33,0xfc,0x23,0x25,0xa9,0xf8,0xfd,0xd2,0x08};
    static std::uint32_t multiplicand40    = 935726744;
    static std::uint8_t  product40[32]     = {0x38,0xf2,0xef,0x01,0xb2,0xf4,0xd9,0x9d,0x73,0x2d,0x30,0xae,0x0b,0xce,0x3a,0x59,0xed,0x64,0x7f,0x1d,0x31,0x1b,0x86,0xee,0x46,0xe2,0xc4,0xf9,0xe2,0x61,0x24,0xc0};
    static std::uint32_t carry40           = 825674588;
    uint256_from_bytes(multiplier, multiplier40);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand40);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product40, product_data, 32) != 0 && carry40 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier41[32]  = {0xd1,0x29,0xd0,0x67,0x43,0xa0,0x8f,0x06,0x17,0x42,0x0e,0x94,0x01,0x44,0x70,0x2b,0xc6,0xb7,0x89,0xef,0x81,0x36,0x5a,0xcc,0x3f,0x88,0xaf,0x59,0x33,0x73,0x6d,0xcc};
    static std::uint32_t multiplicand41    = 617896092;
    static std::uint8_t  product41[32]     = {0xf0,0x25,0x13,0x3f,0xb3,0x51,0xcc,0x75,0xc4,0x02,0x6f,0x13,0x58,0x75,0xc6,0x60,0x17,0xc5,0x08,0x25,0x56,0x69,0x60,0x27,0x74,0xac,0x5b,0x12,0xa5,0x05,0x08,0x50};
    static std::uint32_t carry41           = 504848468;
    uint256_from_bytes(multiplier, multiplier41);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand41);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product41, product_data, 32) != 0 && carry41 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier42[32]  = {0x3b,0x99,0x68,0x70,0xa1,0x32,0x0b,0x9d,0x4d,0xe2,0xf8,0xad,0x4c,0xb5,0x9a,0xa7,0x05,0xc2,0x2d,0x3f,0x64,0xdb,0xc8,0xd3,0x0a,0xaa,0xaf,0x81,0x96,0x38,0x92,0xa7};
    static std::uint32_t multiplicand42    = 3223547465;
    static std::uint8_t  product42[32]     = {0xa9,0xea,0xbf,0xef,0x09,0x2e,0xc7,0xdc,0xb5,0xcd,0x11,0x32,0x51,0x64,0x49,0x95,0xcf,0x1f,0xc5,0x14,0xef,0xd1,0x6b,0xba,0x91,0x77,0xb2,0x39,0x71,0xfa,0x93,0x9f};
    static std::uint32_t carry42           = 750472698;
    uint256_from_bytes(multiplier, multiplier42);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand42);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product42, product_data, 32) != 0 && carry42 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier43[32]  = {0xc3,0xa9,0xe8,0x89,0x63,0xb7,0x59,0xf5,0x98,0xb8,0x1c,0x66,0xe1,0x0c,0x16,0x7d,0xc8,0xb6,0xea,0xff,0xb7,0x4b,0x58,0x9b,0xe4,0x8e,0x9e,0x02,0xa8,0x54,0xc8,0x34};
    static std::uint32_t multiplicand43    = 2122533124;
    static std::uint8_t  product43[32]     = {0x1f,0x59,0x14,0xae,0xc1,0x5c,0x34,0x94,0x0e,0x62,0xe4,0x09,0x61,0xc1,0xf5,0x77,0x68,0xf0,0x78,0x6e,0x6b,0xb5,0xfd,0x5c,0x67,0x7f,0x17,0xf6,0xd9,0x05,0xf4,0xd0};
    static std::uint32_t carry43           = 1622276148;
    uint256_from_bytes(multiplier, multiplier43);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand43);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product43, product_data, 32) != 0 && carry43 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier44[32]  = {0x81,0x6b,0x23,0x32,0xcf,0xed,0x94,0x3b,0xb3,0x78,0x3a,0x7c,0xbb,0xdd,0xbb,0x9b,0x6d,0xe2,0xfb,0x1f,0xa0,0x98,0xd6,0x91,0x83,0x52,0xbc,0x85,0xe4,0x56,0x55,0x9c};
    static std::uint32_t multiplicand44    = 2761190677;
    static std::uint8_t  product44[32]     = {0x22,0x5a,0xee,0x03,0x28,0x17,0x5b,0x49,0xa2,0x3a,0x90,0x98,0xda,0x52,0x81,0xa3,0x19,0xb5,0xd2,0xca,0x84,0x26,0x7b,0x74,0xc3,0xbd,0xc9,0xf5,0xeb,0xb8,0x71,0xcc};
    static std::uint32_t carry44           = 1395895202;
    uint256_from_bytes(multiplier, multiplier44);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand44);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product44, product_data, 32) != 0 && carry44 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier45[32]  = {0x1a,0xdb,0xce,0x5d,0xf5,0xa2,0xd8,0x79,0x5c,0x57,0x53,0x2b,0xa3,0x1a,0x49,0xdd,0x22,0x12,0x65,0x40,0x0a,0xb7,0x79,0x88,0x07,0xfa,0x22,0xf7,0x15,0xc8,0x91,0xff};
    static std::uint32_t multiplicand45    = 3589824707;
    static std::uint8_t  product45[32]     = {0xfb,0x37,0xe1,0x8d,0xdb,0x9e,0x83,0xdd,0xf6,0xaf,0x98,0x53,0xa4,0x4b,0x80,0x48,0x38,0xf0,0x2d,0xa8,0xe1,0xbf,0x6f,0x05,0x55,0x22,0x46,0x27,0x68,0x8e,0xd5,0x3d};
    static std::uint32_t carry45           = 376631754;
    uint256_from_bytes(multiplier, multiplier45);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand45);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product45, product_data, 32) != 0 && carry45 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier46[32]  = {0x3e,0x9b,0x76,0x8f,0xae,0x40,0x01,0xe3,0x88,0x0c,0xb4,0x01,0xa0,0x50,0x60,0x98,0x04,0xd2,0xbe,0x09,0xa0,0xb5,0x58,0x64,0x0c,0xff,0xf0,0x54,0x8e,0xfb,0xa4,0x42};
    static std::uint32_t multiplicand46    = 1132981883;
    static std::uint8_t  product46[32]     = {0xbd,0x4b,0x2f,0x47,0xc6,0x1a,0x82,0x9d,0x87,0x44,0x93,0x7d,0x79,0xd9,0x70,0x64,0xfa,0x11,0x77,0xcc,0x9b,0x78,0x53,0x06,0x0e,0x6a,0x58,0x3f,0x8a,0x6b,0x47,0xb6};
    static std::uint32_t carry46           = 277081685;
    uint256_from_bytes(multiplier, multiplier46);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand46);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product46, product_data, 32) != 0 && carry46 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier47[32]  = {0x89,0x02,0xda,0xfc,0xe5,0xd9,0xfe,0x81,0x80,0xc2,0xb5,0xf1,0xee,0xb8,0x9f,0xf1,0xbf,0x8e,0x51,0xaa,0x11,0xf2,0xd4,0x4d,0xcc,0x35,0xe8,0x34,0x74,0xfa,0x94,0x12};
    static std::uint32_t multiplicand47    = 3164481770;
    static std::uint8_t  product47[32]     = {0x8f,0xb5,0xa2,0x86,0x57,0x83,0x54,0x48,0x15,0x09,0x07,0xd9,0x4d,0xa0,0xb6,0xb6,0xa0,0xfe,0xa0,0x0a,0x83,0x1d,0xd6,0xd0,0xeb,0xd6,0xa9,0x9e,0xaf,0x4a,0x28,0x74};
    static std::uint32_t carry47           = 1693630074;
    uint256_from_bytes(multiplier, multiplier47);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand47);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product47, product_data, 32) != 0 && carry47 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier48[32]  = {0xc1,0xa6,0x24,0xdc,0xba,0xb5,0xb3,0x73,0x3c,0x1a,0xe9,0x17,0x43,0xfb,0x9f,0xbc,0xd8,0x9c,0x36,0xb2,0x13,0x0f,0x27,0xb2,0xcf,0x28,0xf6,0x5e,0x40,0x8f,0xc1,0x46};
    static std::uint32_t multiplicand48    = 1977145508;
    static std::uint8_t  product48[32]     = {0x39,0x1c,0x6f,0x43,0xff,0x83,0x33,0xc5,0x83,0x9c,0x50,0x93,0xf2,0x4f,0xd4,0x8c,0x1b,0x2f,0x4c,0x17,0x36,0xc0,0xd0,0x80,0x39,0x25,0x87,0x7a,0xb8,0x3a,0xe0,0xd8};
    static std::uint32_t carry48           = 1495594728;
    uint256_from_bytes(multiplier, multiplier48);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand48);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product48, product_data, 32) != 0 && carry48 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier49[32]  = {0xc4,0x58,0x27,0x2f,0x49,0x8d,0xbf,0xa8,0xaf,0x06,0xbc,0xf7,0xe9,0x14,0x57,0xdb,0x7a,0xa0,0x68,0xf1,0x13,0xa5,0x39,0x7f,0x61,0xef,0x7b,0xd1,0xd8,0x74,0xbc,0x79};
    static std::uint32_t multiplicand49    = 2760645980;
    static std::uint8_t  product49[32]     = {0x45,0x19,0x78,0xa0,0x5e,0x07,0x05,0x30,0xd2,0xb8,0x7d,0xe7,0xb7,0xd9,0x42,0xb8,0x11,0xf5,0x9d,0x0d,0xd3,0x4b,0x12,0x29,0x78,0x84,0x6d,0x83,0x99,0x79,0x70,0x7c};
    static std::uint32_t carry49           = 2117332948;
    uint256_from_bytes(multiplier, multiplier49);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand49);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product49, product_data, 32) != 0 && carry49 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier50[32]  = {0xb1,0x61,0x07,0xf1,0xbe,0x43,0x7c,0x7b,0xa6,0xca,0xf4,0xa3,0x41,0x02,0x3a,0xed,0x54,0xef,0x12,0x5a,0x25,0xbd,0xa6,0x59,0x99,0x86,0x48,0xe0,0x13,0xd5,0x31,0x6f};
    static std::uint32_t multiplicand50    = 573124782;
    static std::uint8_t  product50[32]     = {0x22,0x6d,0x29,0x53,0x55,0x2a,0x76,0x50,0x48,0x98,0x98,0x55,0x8f,0xda,0xe7,0xf6,0x77,0x62,0x9b,0xd0,0xc0,0xd5,0x49,0xde,0xf5,0x75,0x09,0xbb,0x1c,0xf3,0x69,0x72};
    static std::uint32_t carry50           = 397110611;
    uint256_from_bytes(multiplier, multiplier50);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand50);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product50, product_data, 32) != 0 && carry50 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier51[32]  = {0xb1,0x33,0x0c,0x3f,0x19,0x7a,0x14,0xe2,0xac,0x08,0x4b,0xa5,0xf8,0xf6,0x59,0xac,0x44,0xce,0x4a,0xb3,0x7c,0x5d,0x42,0xdc,0x0f,0x87,0x7a,0xe3,0x7b,0x7f,0xec,0x4b};
    static std::uint32_t multiplicand51    = 2902142302;
    static std::uint8_t  product51[32]     = {0x70,0xe1,0x97,0x60,0x96,0x53,0xc2,0x6e,0x4f,0x58,0x91,0x7e,0x62,0x5a,0x45,0xcd,0x5c,0x6a,0x93,0x20,0x77,0x31,0x7b,0xee,0xd8,0x5d,0x25,0x6b,0xe7,0x0a,0xf2,0x8a};
    static std::uint32_t carry51           = 2008819886;
    uint256_from_bytes(multiplier, multiplier51);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand51);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product51, product_data, 32) != 0 && carry51 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier52[32]  = {0xc4,0x65,0x3c,0xde,0x77,0x62,0x00,0xb5,0x77,0x45,0x10,0xca,0x76,0xf4,0x25,0x1e,0x49,0x19,0x61,0xa1,0x84,0x3b,0xae,0xe9,0xb5,0x78,0x90,0x9c,0x4a,0x75,0x91,0xf2};
    static std::uint32_t multiplicand52    = 2358265662;
    static std::uint8_t  product52[32]     = {0x8a,0xd3,0x30,0x80,0xbb,0x3b,0x5c,0x0f,0x35,0x52,0xa5,0xa7,0xf6,0x6f,0x63,0x46,0xfd,0x64,0x76,0x04,0xc6,0xab,0x30,0xd5,0x33,0xf0,0x8c,0x73,0x14,0x13,0x76,0x9c};
    static std::uint32_t carry52           = 1809190115;
    uint256_from_bytes(multiplier, multiplier52);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand52);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product52, product_data, 32) != 0 && carry52 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier53[32]  = {0x75,0x7f,0x1c,0xba,0x4a,0x22,0x7f,0x39,0x04,0x7b,0x2c,0x10,0x79,0x12,0xef,0x4a,0xef,0xae,0x5d,0x4e,0x15,0xfa,0x8b,0x65,0xfa,0x66,0x72,0xcd,0x4f,0xc9,0xe9,0x18};
    static std::uint32_t multiplicand53    = 1153874069;
    static std::uint8_t  product53[32]     = {0x73,0x68,0x1e,0x2f,0x7c,0xcf,0x36,0x60,0x98,0x43,0x28,0xd1,0x0f,0xa2,0xd4,0x87,0xbb,0xc7,0xfb,0x0d,0xc6,0x67,0x50,0x0f,0xb4,0x21,0xba,0xed,0x38,0x9d,0xea,0xf8};
    static std::uint32_t carry53           = 529594537;
    uint256_from_bytes(multiplier, multiplier53);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand53);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product53, product_data, 32) != 0 && carry53 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier54[32]  = {0x17,0x1e,0x1a,0x8c,0x94,0xdb,0x5f,0x8f,0x13,0x19,0xd4,0x24,0x35,0xf1,0x03,0x00,0xee,0x37,0x9c,0x65,0xf2,0x12,0x01,0xe4,0xea,0xa3,0x55,0x6c,0x35,0xb7,0xe4,0x48};
    static std::uint32_t multiplicand54    = 1544270863;
    static std::uint8_t  product54[32]     = {0x2e,0xf7,0xa2,0xab,0x7e,0x0e,0x4d,0x29,0x68,0x9d,0xd2,0x7c,0x15,0xe2,0x0d,0x25,0x6a,0x99,0xb7,0xa2,0x31,0x8b,0xd9,0x1c,0x26,0x96,0x7c,0x0d,0x21,0x61,0x00,0x38};
    static std::uint32_t carry54           = 139452440;
    uint256_from_bytes(multiplier, multiplier54);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand54);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product54, product_data, 32) != 0 && carry54 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier55[32]  = {0xb4,0x0d,0xe5,0x6d,0x1c,0xd8,0x6f,0xc1,0xe3,0x09,0x66,0x19,0x47,0x91,0xc2,0xe9,0x82,0x3d,0x11,0xed,0xa1,0xb5,0x01,0xd6,0xd1,0xf9,0xbd,0xfe,0x9a,0x76,0x2d,0x54};
    static std::uint32_t multiplicand55    = 993785023;
    static std::uint8_t  product55[32]     = {0x9a,0xd5,0xb3,0x8a,0x41,0x02,0xab,0xbf,0xb4,0xa5,0x5b,0x97,0x10,0x5c,0x13,0x8f,0x46,0xaf,0xda,0x90,0x1a,0xb4,0x12,0xc1,0x29,0xb2,0x41,0xdc,0xaf,0xbb,0xe1,0xac};
    static std::uint32_t carry55           = 698965815;
    uint256_from_bytes(multiplier, multiplier55);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand55);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product55, product_data, 32) != 0 && carry55 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier56[32]  = {0xf3,0x30,0x8c,0xe5,0x00,0xeb,0x4e,0x11,0x28,0xb8,0x80,0x73,0x06,0x5b,0x8c,0x35,0x64,0xe2,0x76,0x02,0x7c,0x73,0xb6,0xc9,0xe0,0x4b,0x0d,0xce,0xe5,0xd0,0x0a,0x4d};
    static std::uint32_t multiplicand56    = 2927398665;
    static std::uint8_t  product56[32]     = {0x90,0xf5,0x40,0x99,0xf2,0xde,0x75,0x05,0xe4,0x46,0x12,0x3c,0x90,0xf8,0x8b,0x21,0xe5,0xac,0x77,0xe4,0xc3,0x67,0xd9,0x20,0x1f,0xc4,0xc6,0x6a,0x9d,0x5d,0x5f,0xb5};
    static std::uint32_t carry56           = 2780910376;
    uint256_from_bytes(multiplier, multiplier56);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand56);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product56, product_data, 32) != 0 && carry56 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier57[32]  = {0x50,0xea,0x7d,0xa7,0x60,0x48,0x7e,0x15,0x58,0x0d,0xc5,0xab,0x6a,0x8a,0xd9,0xcb,0x24,0x05,0x63,0x60,0xba,0x28,0xa6,0x79,0x4d,0x4c,0xa9,0xc7,0x67,0xc9,0x8f,0xb9};
    static std::uint32_t multiplicand57    = 3608764809;
    static std::uint8_t  product57[32]     = {0xfe,0x4e,0xf3,0x06,0x3b,0x9a,0xba,0x24,0x9b,0x7c,0xc0,0x93,0x80,0xeb,0x91,0x59,0x42,0x54,0x27,0x15,0x28,0x98,0xfc,0x47,0x76,0xfe,0xd4,0x6d,0x52,0x64,0x03,0x01};
    static std::uint32_t carry57           = 1140651329;
    uint256_from_bytes(multiplier, multiplier57);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand57);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product57, product_data, 32) != 0 && carry57 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier58[32]  = {0x5f,0x49,0xf0,0xfc,0x40,0xd2,0x84,0x06,0x4a,0x32,0x7e,0x2d,0xbd,0x6a,0x99,0x6d,0xe6,0xcd,0x10,0xf1,0x03,0x00,0x30,0x05,0xb6,0x88,0xb6,0x61,0x32,0x1c,0x17,0x44};
    static std::uint32_t multiplicand58    = 1687489986;
    static std::uint8_t  product58[32]     = {0xc3,0x69,0x64,0x8d,0x1c,0xe1,0x47,0x36,0x19,0x48,0xd4,0x42,0x2f,0xb2,0x49,0xfa,0x52,0xb5,0xe5,0xa9,0x77,0x35,0x53,0x69,0x63,0x02,0x48,0xa3,0x81,0x0c,0x15,0x88};
    static std::uint32_t carry58           = 628120906;
    uint256_from_bytes(multiplier, multiplier58);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand58);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product58, product_data, 32) != 0 && carry58 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier59[32]  = {0xc1,0x72,0xb2,0x98,0x6d,0x94,0xdd,0x6d,0xec,0xe8,0x07,0x99,0x5c,0x57,0x72,0x2e,0x13,0x8e,0xfe,0xf9,0x96,0xd4,0x48,0x0f,0xde,0xb6,0x7a,0xe7,0xff,0xb0,0xdd,0x9e};
    static std::uint32_t multiplicand59    = 3668998441;
    static std::uint8_t  product59[32]     = {0xc7,0xe4,0xc1,0x1c,0xc0,0xd0,0xe1,0x92,0x6e,0xd2,0xa7,0x8e,0xdb,0x4e,0x48,0x0f,0x8e,0x73,0x45,0x92,0x8c,0x9f,0x8c,0xec,0xfa,0x8d,0xbd,0x53,0x74,0xb3,0x2c,0x4e};
    static std::uint32_t carry59           = 2772502142;
    uint256_from_bytes(multiplier, multiplier59);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand59);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product59, product_data, 32) != 0 && carry59 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier60[32]  = {0xef,0x82,0xd1,0xa3,0xa2,0x8c,0xf7,0xb1,0x49,0x1e,0x99,0xf5,0xa9,0x77,0x66,0xfb,0xd5,0xad,0x53,0x60,0x0d,0x36,0xce,0x2c,0x1a,0x09,0xa8,0x40,0x47,0xd7,0xdf,0x79};
    static std::uint32_t multiplicand60    = 1141293139;
    static std::uint8_t  product60[32]     = {0x25,0xa7,0xf3,0x10,0x53,0x0d,0x1c,0xee,0x85,0x29,0xd9,0xe6,0xcd,0x9c,0x50,0x1d,0xbd,0x7c,0xf0,0x19,0xef,0x59,0x18,0xbe,0xb3,0xe8,0xc9,0x24,0x93,0x6e,0x34,0x3b};
    static std::uint32_t carry60           = 1067782320;
    uint256_from_bytes(multiplier, multiplier60);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand60);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product60, product_data, 32) != 0 && carry60 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier61[32]  = {0x69,0x2f,0xd3,0x60,0xbb,0x7b,0x73,0x8e,0xee,0xf7,0x95,0xcd,0x0c,0xaa,0x76,0x12,0x14,0xa0,0xb0,0x0b,0xb8,0x35,0xe8,0xa5,0x34,0x14,0x5e,0x87,0x8c,0x9a,0x37,0x51};
    static std::uint32_t multiplicand61    = 3734383213;
    static std::uint8_t  product61[32]     = {0x5f,0x4d,0xc7,0x7d,0xbd,0x80,0x60,0x09,0xf5,0x1f,0xaa,0xa7,0x38,0x6e,0xab,0xe6,0x75,0xe9,0x90,0x8b,0xdb,0x15,0x56,0xcb,0x73,0x88,0x9b,0x1c,0xd2,0x32,0xd7,0x7d};
    static std::uint32_t carry61           = 1534405826;
    uint256_from_bytes(multiplier, multiplier61);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand61);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product61, product_data, 32) != 0 && carry61 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier62[32]  = {0x78,0xe1,0x0e,0x70,0x2b,0xb7,0x1c,0x68,0x20,0x97,0x79,0x8c,0x8c,0xd3,0xe4,0x18,0xed,0x41,0x42,0xba,0xe9,0x72,0x9f,0x3f,0x0c,0x89,0xc0,0x01,0x7c,0x4e,0xa6,0x03};
    static std::uint32_t multiplicand62    = 1476020709;
    static std::uint8_t  product62[32]     = {0x86,0xd5,0xd2,0x47,0x72,0xa9,0x68,0xab,0xd0,0x46,0x58,0x53,0x9e,0x8f,0x05,0x5c,0x87,0x45,0xeb,0xd2,0x73,0xc6,0x7c,0xbf,0x81,0xab,0x4c,0xff,0xc3,0x9f,0x5b,0xaf};
    static std::uint32_t carry62           = 696953492;
    uint256_from_bytes(multiplier, multiplier62);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand62);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product62, product_data, 32) != 0 && carry62 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier63[32]  = {0x8c,0xe6,0x21,0xef,0x7f,0x40,0x5b,0xc8,0xcf,0xd3,0xdd,0x72,0xe7,0xec,0xfd,0x0c,0x80,0x27,0xa2,0xa2,0x35,0x37,0x22,0x35,0x13,0x3e,0x61,0x53,0x29,0x62,0x59,0xc8};
    static std::uint32_t multiplicand63    = 3260944719;
    static std::uint8_t  product63[32]     = {0xb7,0xa4,0xdf,0x8b,0x6c,0x2f,0x86,0x61,0x98,0x08,0xb8,0xa4,0xb2,0xa5,0x03,0x2a,0xd1,0xeb,0x47,0xc1,0xdd,0x5b,0x6b,0x50,0xd6,0x9c,0x48,0x8f,0xd4,0xbf,0xfc,0xb8};
    static std::uint32_t carry63           = 1794780094;
    uint256_from_bytes(multiplier, multiplier63);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand63);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product63, product_data, 32) != 0 && carry63 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier64[32]  = {0x86,0x2f,0xe2,0x31,0xbe,0xef,0x67,0xfb,0x69,0xf4,0x46,0x12,0x62,0x01,0xa9,0xd3,0x69,0xac,0x0f,0x03,0xde,0xe0,0xa8,0x43,0xbf,0xe9,0x8f,0x8c,0x05,0x24,0x13,0x7f};
    static std::uint32_t multiplicand64    = 1618626354;
    static std::uint8_t  product64[32]     = {0xf0,0x64,0xbe,0xc1,0x86,0x25,0x22,0x2d,0xba,0xa8,0x1d,0x3f,0xd0,0xcd,0xaf,0x39,0xf7,0x31,0x77,0xbb,0x6e,0xcc,0xb2,0x98,0x2d,0x15,0xd9,0x46,0xec,0xfa,0x07,0xce};
    static std::uint32_t carry64           = 848432373;
    uint256_from_bytes(multiplier, multiplier64);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand64);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product64, product_data, 32) != 0 && carry64 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier65[32]  = {0x5c,0x32,0x7a,0x6d,0xf7,0xba,0x38,0xb6,0x93,0x04,0x10,0x6e,0x47,0x0b,0x4f,0xad,0x7f,0x86,0x7d,0x5f,0x0f,0xe3,0x21,0xec,0xc0,0x8a,0x58,0xd7,0x56,0x94,0x7a,0x7a};
    static std::uint32_t multiplicand65    = 3644847894;
    static std::uint8_t  product65[32]     = {0xf8,0x83,0x70,0x5e,0xae,0x45,0xa7,0x77,0x13,0x8f,0xe2,0x58,0xb1,0xa4,0xa1,0x52,0x27,0x61,0xef,0x26,0x8b,0xb8,0xff,0x78,0x6c,0xfd,0x91,0x66,0x40,0xf4,0x3c,0x7c};
    static std::uint32_t carry65           = 1312674607;
    uint256_from_bytes(multiplier, multiplier65);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand65);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product65, product_data, 32) != 0 && carry65 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier66[32]  = {0x72,0x23,0xc6,0x8a,0xa5,0x52,0x9b,0x05,0x66,0x56,0x7b,0xc4,0x62,0x72,0x92,0xf8,0x3f,0x9a,0xa8,0x84,0xe5,0x94,0x09,0xc1,0x45,0x61,0x9f,0xc0,0x17,0xb4,0x83,0x4c};
    static std::uint32_t multiplicand66    = 4097156467;
    static std::uint8_t  product66[32]     = {0x95,0x50,0x82,0xb1,0xbf,0xae,0xbc,0x41,0x84,0x1c,0xc2,0x79,0x1c,0x36,0x9a,0x26,0xcf,0x6b,0xfc,0x9d,0xc6,0xee,0x5d,0x03,0x40,0x2e,0x88,0x15,0x9d,0x72,0xf7,0x24};
    static std::uint32_t carry66           = 1826751592;
    uint256_from_bytes(multiplier, multiplier66);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand66);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product66, product_data, 32) != 0 && carry66 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier67[32]  = {0x00,0x0b,0xb5,0xf9,0x7d,0x65,0x21,0x35,0x96,0x51,0x32,0xd6,0xf7,0xe1,0x47,0xfd,0x79,0x28,0x1c,0x19,0xcd,0xe3,0x47,0xab,0xe5,0x4c,0x5d,0xe6,0xc3,0x81,0x3c,0xe6};
    static std::uint32_t multiplicand67    = 3674184203;
    static std::uint8_t  product67[32]     = {0xc4,0x44,0xed,0x2a,0xef,0xb4,0x89,0xe7,0x01,0x49,0x41,0x0e,0xba,0xa4,0x69,0xa8,0x4c,0xa8,0x5b,0x63,0x57,0x5d,0xeb,0x5a,0xd6,0x1d,0xa6,0x1d,0xaa,0x49,0xf9,0xe2};
    static std::uint32_t carry67           = 656551;
    uint256_from_bytes(multiplier, multiplier67);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand67);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product67, product_data, 32) != 0 && carry67 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier68[32]  = {0xc3,0x8b,0x48,0xa2,0xb2,0xd6,0x43,0xa2,0x6f,0xfb,0x72,0x6a,0xa2,0xe3,0xf9,0x3a,0x87,0x3b,0x99,0x03,0x40,0x75,0x91,0x6e,0xa0,0x60,0x84,0x6c,0x20,0xc2,0x6f,0x71};
    static std::uint32_t multiplicand68    = 427112113;
    static std::uint8_t  product68[32]     = {0xaa,0x72,0x32,0xbe,0x9e,0x95,0xc3,0x06,0x2b,0xa1,0x4f,0x9e,0x55,0x26,0x4a,0x2c,0x52,0x43,0x6b,0xc7,0xa3,0x2f,0x9c,0x5c,0x53,0x48,0x53,0x6a,0xa1,0x95,0xe3,0x21};
    static std::uint32_t carry68           = 326247046;
    uint256_from_bytes(multiplier, multiplier68);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand68);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product68, product_data, 32) != 0 && carry68 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier69[32]  = {0x0e,0x28,0xb6,0x4f,0x4e,0xb1,0x9f,0xca,0xa6,0x4f,0x76,0x13,0xb4,0x64,0x2e,0xa4,0x69,0x6c,0x63,0xd6,0xf5,0xea,0xd0,0x65,0x07,0x7e,0xf3,0x2a,0x3f,0x3f,0x37,0xea};
    static std::uint32_t multiplicand69    = 833718554;
    static std::uint8_t  product69[32]     = {0x74,0x98,0x5d,0x90,0x51,0x7f,0xe0,0x1f,0xd3,0x69,0x6f,0xbb,0xa6,0xfd,0x5c,0x2a,0xe3,0x22,0x26,0xad,0x0f,0xa8,0xb6,0x96,0xe9,0x57,0x22,0x8c,0xb4,0x21,0xe7,0xc4};
    static std::uint32_t carry69           = 46111904;
    uint256_from_bytes(multiplier, multiplier69);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand69);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product69, product_data, 32) != 0 && carry69 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier70[32]  = {0xaa,0xd7,0xc7,0xc0,0x3a,0x53,0xc1,0x76,0x41,0xdb,0x89,0x8e,0x14,0xc2,0x73,0x2a,0x6b,0x86,0x29,0x0b,0xa5,0xac,0xd3,0x41,0xac,0xa9,0x9f,0xd0,0xe2,0x85,0x6e,0xc6};
    static std::uint32_t multiplicand70    = 3973535499;
    static std::uint8_t  product70[32]     = {0xa4,0x5e,0x1b,0xc5,0x77,0x60,0x32,0xa5,0xf1,0xa4,0xe3,0xa2,0xcd,0x3e,0x58,0xe0,0x6c,0x3a,0x2f,0xb3,0xd1,0x8c,0xc7,0x49,0xd9,0xdb,0x1b,0x23,0xa4,0xab,0x0c,0x82};
    static std::uint32_t carry70           = 2651758964;
    uint256_from_bytes(multiplier, multiplier70);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand70);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product70, product_data, 32) != 0 && carry70 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier71[32]  = {0x81,0x3f,0xb5,0xcd,0xd8,0x5b,0xbb,0x6b,0xbd,0x37,0x92,0x9d,0x4a,0xc7,0xcc,0xc3,0xcc,0x0c,0x66,0x82,0x01,0xba,0x98,0x5a,0x32,0xb5,0x58,0xfd,0x65,0x77,0xbb,0x54};
    static std::uint32_t multiplicand71    = 881407128;
    static std::uint8_t  product71[32]     = {0xc9,0xdd,0x2d,0x54,0x47,0xa0,0xb6,0xed,0x0c,0x24,0x9b,0x19,0x56,0x74,0x11,0x28,0xf0,0x1c,0x19,0x58,0xc8,0x4e,0xc0,0xfb,0x09,0xf7,0xee,0x30,0xe1,0x18,0x49,0xe0};
    static std::uint32_t carry71           = 445003411;
    uint256_from_bytes(multiplier, multiplier71);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand71);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product71, product_data, 32) != 0 && carry71 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier72[32]  = {0x77,0x11,0xb7,0x57,0x3b,0x16,0x49,0x43,0x31,0xa5,0x9c,0x4a,0xd1,0xeb,0xd0,0x86,0xc4,0x0f,0x36,0x09,0x4f,0xcc,0x9a,0x5c,0x33,0x4e,0x51,0xaf,0xf8,0x48,0xa9,0x56};
    static std::uint32_t multiplicand72    = 3819659907;
    static std::uint8_t  product72[32]     = {0x86,0xe9,0x71,0x1b,0x49,0x5b,0x39,0x99,0x8b,0xb1,0xf1,0x11,0x7b,0x5d,0xbf,0x17,0x80,0x72,0xf1,0xdb,0x05,0xdf,0x00,0x91,0xd6,0x0c,0x70,0xc8,0x3c,0x73,0x93,0x02};
    static std::uint32_t carry72           = 1776577593;
    uint256_from_bytes(multiplier, multiplier72);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand72);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product72, product_data, 32) != 0 && carry72 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier73[32]  = {0x39,0x2b,0xc5,0x52,0xe5,0x7f,0x76,0x91,0x2f,0xf3,0xc2,0x3c,0x9c,0x2f,0x67,0x23,0x7e,0xea,0x6f,0xe1,0x9f,0xa4,0x0d,0xd6,0xf3,0xb1,0x7a,0xf0,0x1b,0xe7,0xf3,0xcf};
    static std::uint32_t multiplicand73    = 2857417071;
    static std::uint8_t  product73[32]     = {0x21,0xe1,0xd3,0x5c,0x16,0x2a,0x2f,0xc3,0xe4,0xb7,0x4e,0x73,0xc7,0x75,0xb6,0xaa,0x3d,0x05,0x63,0xa6,0xd7,0x22,0x59,0x68,0xc9,0x5c,0x92,0xaa,0x5f,0x73,0x4d,0xc1};
    static std::uint32_t carry73           = 638130208;
    uint256_from_bytes(multiplier, multiplier73);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand73);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product73, product_data, 32) != 0 && carry73 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier74[32]  = {0x64,0xb0,0xbb,0x14,0x2f,0x21,0x7e,0x72,0x0f,0x65,0x06,0x38,0xb5,0xb9,0x4a,0xf3,0x0d,0x45,0x6b,0xe0,0x6a,0x56,0xaa,0xc3,0x24,0x54,0x48,0xc8,0x98,0x9b,0xc9,0xdc};
    static std::uint32_t multiplicand74    = 3794962836;
    static std::uint8_t  product74[32]     = {0x25,0xd6,0xbb,0x0f,0x8f,0xe6,0x55,0x67,0x3e,0x3d,0x04,0x64,0x6d,0x6b,0x47,0x69,0x02,0x92,0xbe,0x53,0x7b,0xac,0xa7,0xf9,0x69,0x94,0xc4,0x45,0x3e,0x0f,0x6f,0x30};
    static std::uint32_t carry74           = 1492641225;
    uint256_from_bytes(multiplier, multiplier74);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand74);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product74, product_data, 32) != 0 && carry74 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier75[32]  = {0x30,0xd0,0xa2,0xb8,0x54,0x49,0x40,0xe1,0x2a,0x66,0xf9,0x13,0xee,0x7d,0x0a,0xe2,0x14,0x51,0x03,0xc7,0xff,0x5e,0x1d,0x1f,0x1c,0xfb,0x0a,0x06,0xbb,0x93,0xc8,0xeb};
    static std::uint32_t multiplicand75    = 2008394699;
    static std::uint8_t  product75[32]     = {0xcd,0xa3,0xcd,0x6b,0x4e,0x55,0xb2,0x75,0xc6,0xfb,0x91,0x93,0x6c,0xb6,0xaa,0xe1,0xdd,0xe0,0xe4,0x3f,0x6a,0x8d,0x0f,0x2e,0xe2,0xb7,0xc4,0x84,0xc0,0x8c,0x4b,0x59};
    static std::uint32_t carry75           = 382967784;
    uint256_from_bytes(multiplier, multiplier75);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand75);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product75, product_data, 32) != 0 && carry75 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier76[32]  = {0x54,0xea,0x20,0x61,0xfc,0x27,0xd6,0x83,0x5f,0xb6,0xd6,0x25,0xd6,0xd1,0x06,0xfb,0x60,0xed,0x33,0xa0,0xb9,0xb2,0x53,0xe3,0xaa,0x18,0x13,0x45,0x4f,0xd3,0xe7,0x58};
    static std::uint32_t multiplicand76    = 726970231;
    static std::uint8_t  product76[32]     = {0x9a,0x79,0x77,0x05,0xe6,0x57,0xa3,0x76,0x19,0xe1,0x02,0x32,0x42,0xb3,0xbb,0x9d,0x24,0x7b,0xc1,0x41,0xfd,0x83,0x7b,0x3d,0x7d,0x84,0x20,0x2d,0xa7,0x85,0xb1,0xe8};
    static std::uint32_t carry76           = 241134198;
    uint256_from_bytes(multiplier, multiplier76);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand76);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product76, product_data, 32) != 0 && carry76 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier77[32]  = {0xe2,0x9a,0xac,0xea,0xf4,0x9c,0x9e,0xba,0x6b,0x91,0x1f,0x97,0x59,0xf9,0xbb,0x79,0x14,0xac,0xe1,0xcb,0x47,0xa1,0x64,0xe4,0x14,0x07,0xab,0x33,0x00,0xbc,0x22,0xcb};
    static std::uint32_t multiplicand77    = 3259042513;
    static std::uint8_t  product77[32]     = {0x00,0x0f,0x25,0x6d,0x64,0xea,0x28,0x2f,0x34,0x53,0xcc,0x8e,0x91,0x9e,0x0b,0xaa,0x02,0xdb,0xc6,0x31,0x3d,0xcb,0x2c,0xab,0xc5,0x74,0x84,0xcd,0x9e,0x7f,0x55,0xbb};
    static std::uint32_t carry77           = 2884815331;
    uint256_from_bytes(multiplier, multiplier77);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand77);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product77, product_data, 32) != 0 && carry77 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier78[32]  = {0x6e,0xb4,0xff,0xf8,0xcd,0xce,0xc4,0x08,0xd2,0x6f,0x1d,0x76,0x4f,0x06,0xe9,0x5a,0xd2,0x52,0xa6,0x17,0xc4,0xcb,0xa0,0x38,0x5b,0x4c,0x0d,0x73,0x61,0x50,0x2d,0xee};
    static std::uint32_t multiplicand78    = 2033512632;
    static std::uint8_t  product78[32]     = {0xd9,0xe1,0xc4,0x6d,0xc1,0xa6,0x6f,0x1e,0x52,0xde,0x68,0xd2,0x9b,0x98,0xa7,0xbf,0x9f,0xf5,0xe1,0xab,0x87,0x29,0x7b,0xe7,0x2f,0xb4,0x80,0x27,0xef,0x08,0x23,0x10};
    static std::uint32_t carry78           = 879391193;
    uint256_from_bytes(multiplier, multiplier78);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand78);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product78, product_data, 32) != 0 && carry78 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier79[32]  = {0xc4,0x44,0x5a,0xae,0xa0,0x1a,0xc2,0x3a,0xcf,0xd3,0xbb,0x74,0x3f,0x7d,0xc8,0x6b,0x69,0x2a,0x4f,0x0e,0xa1,0xb4,0x9b,0xf7,0x07,0xc0,0x90,0x9c,0x79,0x7b,0x15,0x38};
    static std::uint32_t multiplicand79    = 174588221;
    static std::uint8_t  product79[32]     = {0xb1,0xd6,0x60,0xb1,0x75,0x25,0x36,0x2a,0x0a,0xe3,0xd3,0xe0,0x3c,0x7f,0x8d,0x47,0xe9,0xa6,0xa4,0x95,0x3f,0x4d,0xcc,0xc5,0x75,0xc3,0x3a,0x97,0x3c,0x29,0x46,0x58};
    static std::uint32_t carry79           = 133851202;
    uint256_from_bytes(multiplier, multiplier79);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand79);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product79, product_data, 32) != 0 && carry79 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier80[32]  = {0xec,0x9a,0x36,0x0c,0x51,0x05,0x12,0x2a,0xb0,0x88,0x24,0x11,0xb7,0x75,0x70,0xa4,0xbf,0x16,0x8d,0xa7,0x43,0x1d,0xbc,0x3f,0x0b,0x28,0x6c,0x70,0x9d,0xf2,0x4d,0x5e};
    static std::uint32_t multiplicand80    = 1277348535;
    static std::uint8_t  product80[32]     = {0xa6,0x92,0x9e,0xcd,0x01,0x09,0x88,0x99,0xaa,0x98,0xfe,0x76,0xae,0x71,0x97,0x98,0xdd,0x08,0xfb,0x5c,0x28,0x7a,0xcb,0x6e,0xb5,0x4f,0x4a,0x48,0x47,0xbd,0x7a,0x32};
    static std::uint32_t carry80           = 1180561377;
    uint256_from_bytes(multiplier, multiplier80);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand80);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product80, product_data, 32) != 0 && carry80 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier81[32]  = {0xf1,0x78,0xd7,0x7f,0xf2,0x4d,0x04,0xfd,0xa2,0x4c,0x84,0x07,0xce,0x3f,0xa0,0x28,0xea,0x9d,0x18,0xb2,0x98,0x77,0x27,0x90,0xc1,0x72,0x6f,0x06,0xb8,0xb8,0xf2,0x70};
    static std::uint32_t multiplicand81    = 1004447939;
    static std::uint8_t  product81[32]     = {0x9a,0x43,0xfc,0x68,0xe4,0x4b,0xa0,0x7d,0x22,0x3b,0x36,0x62,0x2d,0x1f,0x82,0x0e,0x61,0xe2,0xb1,0x8b,0x00,0xd7,0x43,0x09,0x47,0x6d,0xcb,0x9a,0x21,0x1a,0x2b,0x50};
    static std::uint32_t carry81           = 947445668;
    uint256_from_bytes(multiplier, multiplier81);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand81);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product81, product_data, 32) != 0 && carry81 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier82[32]  = {0xca,0x30,0x42,0x18,0x62,0xf2,0xa2,0x1b,0xc6,0xbf,0x4f,0xa2,0xf4,0x33,0x7b,0xd1,0x77,0x3a,0xfe,0x02,0xf4,0xef,0x61,0x42,0xb7,0x2f,0xac,0x4a,0x79,0xa5,0xfd,0x62};
    static std::uint32_t multiplicand82    = 3923641465;
    static std::uint8_t  product82[32]     = {0xd5,0x0c,0x43,0x06,0x6b,0x31,0x87,0x9e,0x4d,0x3d,0xd0,0x2d,0x3f,0x6e,0xe2,0x37,0x3e,0x58,0x62,0x55,0x93,0x3f,0x42,0x8c,0x85,0x87,0x2a,0xaa,0x04,0x66,0x4b,0x52};
    static std::uint32_t carry82           = 3098887561;
    uint256_from_bytes(multiplier, multiplier82);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand82);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product82, product_data, 32) != 0 && carry82 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier83[32]  = {0x3c,0x73,0xd5,0xf4,0x9b,0x75,0x03,0x62,0x26,0xbc,0x98,0x58,0xc5,0xd6,0xd5,0xe9,0xb1,0x2e,0x1d,0xe2,0xd2,0xa0,0x16,0x9d,0x4d,0xa6,0x09,0x90,0xbd,0x0d,0x8c,0xfe};
    static std::uint32_t multiplicand83    = 3699007837;
    static std::uint8_t  product83[32]     = {0x06,0x51,0x0d,0x6f,0xc5,0xda,0xf4,0x22,0x6c,0x8f,0xe3,0x6d,0x0b,0xbb,0x53,0xb1,0x02,0x2d,0xc0,0xef,0x22,0x6b,0x82,0xea,0x10,0x63,0x0e,0xd6,0x49,0x64,0x76,0x46};
    static std::uint32_t carry83           = 873493008;
    uint256_from_bytes(multiplier, multiplier83);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand83);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product83, product_data, 32) != 0 && carry83 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier84[32]  = {0x32,0x83,0x06,0x89,0x83,0x0a,0xe1,0x9e,0x14,0x3a,0x51,0x80,0x98,0x80,0xe8,0x8b,0xc8,0x41,0x72,0x1e,0xc8,0xa9,0x48,0x14,0x5c,0xa2,0xc1,0x32,0x75,0xf5,0xc1,0xa0};
    static std::uint32_t multiplicand84    = 3233619332;
    static std::uint8_t  product84[32]     = {0xd9,0x1a,0xda,0xfe,0xee,0x0b,0xe9,0xfb,0xa7,0x9e,0xdd,0x29,0xc2,0x33,0xab,0xab,0x02,0xe5,0x6f,0xa4,0x20,0xf5,0xee,0x0c,0xae,0x87,0xbd,0x09,0x9c,0xc6,0xf6,0x80};
    static std::uint32_t carry84           = 638031221;
    uint256_from_bytes(multiplier, multiplier84);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand84);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product84, product_data, 32) != 0 && carry84 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier85[32]  = {0x8b,0x6b,0xfe,0xae,0x8d,0x76,0xd7,0xa1,0x7b,0x50,0x07,0x9e,0x08,0xab,0x4a,0xe4,0xa6,0x48,0xa5,0x8c,0x10,0x92,0x57,0xf7,0x68,0x62,0xbf,0x79,0x3f,0x4f,0x8b,0x9d};
    static std::uint32_t multiplicand85    = 309946508;
    static std::uint8_t  product85[32]     = {0xc4,0xf9,0x69,0x42,0xea,0x96,0x6f,0xc4,0xa9,0x2a,0x82,0x2c,0xcd,0xdd,0x8c,0x92,0x8b,0x59,0x8e,0xaf,0x7d,0x0b,0xe5,0xd8,0x3a,0x8c,0x7c,0x70,0xf7,0x6d,0x21,0xdc};
    static std::uint32_t carry85           = 168802019;
    uint256_from_bytes(multiplier, multiplier85);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand85);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product85, product_data, 32) != 0 && carry85 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier86[32]  = {0x27,0x40,0x1f,0xa0,0x3c,0x49,0xfd,0xbd,0x3e,0xce,0x9f,0x2c,0x2f,0x8c,0x6c,0x08,0x3f,0x57,0x83,0xea,0x70,0x7c,0x5f,0x3d,0x32,0xfe,0x1f,0x36,0x42,0xa5,0x51,0x62};
    static std::uint32_t multiplicand86    = 2483696951;
    static std::uint8_t  product86[32]     = {0x94,0x70,0x19,0x7d,0x97,0x21,0x99,0xc1,0x08,0x8f,0x62,0x47,0x46,0x79,0xfc,0x91,0x6a,0x4d,0x2c,0x93,0x04,0x4f,0x09,0xad,0x27,0xb5,0x1d,0xf6,0x61,0x31,0xc6,0x0e};
    static std::uint32_t carry86           = 380805874;
    uint256_from_bytes(multiplier, multiplier86);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand86);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product86, product_data, 32) != 0 && carry86 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier87[32]  = {0x86,0xbc,0x2b,0x99,0x81,0xe0,0x04,0xfb,0x3e,0xf6,0x87,0x56,0xfe,0x11,0x1e,0xbc,0x40,0x6c,0x61,0x32,0x65,0x64,0xd1,0x34,0x10,0x97,0x00,0x46,0x53,0x8a,0xe1,0xc1};
    static std::uint32_t multiplicand87    = 159013186;
    static std::uint8_t  product87[32]     = {0x54,0x64,0x60,0xa9,0x92,0x6f,0x4d,0xe8,0x7e,0xff,0xd0,0xfe,0xb8,0x13,0xe1,0xff,0x61,0x50,0x71,0xa4,0xb8,0x1e,0x40,0x29,0x60,0x7a,0x37,0x4c,0x31,0x44,0x4c,0xc2};
    static std::uint32_t carry87           = 83690031;
    uint256_from_bytes(multiplier, multiplier87);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand87);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product87, product_data, 32) != 0 && carry87 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier88[32]  = {0xea,0x14,0x84,0x3a,0x72,0xc3,0x9a,0x28,0xd7,0x2e,0xb3,0xa1,0x3b,0x2a,0x42,0x1a,0xd1,0xb0,0xb7,0x0b,0xe2,0x00,0xd2,0x18,0x79,0x8a,0x0d,0x59,0x01,0x26,0x64,0xf6};
    static std::uint32_t multiplicand88    = 1261335109;
    static std::uint8_t  product88[32]     = {0x1c,0x89,0x98,0x2b,0xb3,0xc0,0x15,0xd9,0x4e,0xe2,0x39,0xc3,0x80,0x14,0x35,0xfc,0x95,0x7d,0x7a,0x8b,0x33,0xc8,0xcf,0x6f,0xb5,0x7b,0xaf,0xfa,0x9e,0x82,0xc2,0x4e};
    static std::uint32_t carry88           = 1153333993;
    uint256_from_bytes(multiplier, multiplier88);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand88);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product88, product_data, 32) != 0 && carry88 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier89[32]  = {0xd0,0x93,0x0b,0x64,0x34,0x14,0xc2,0xdc,0xe9,0xf8,0xf7,0x1f,0xa6,0xd2,0x10,0x40,0xbb,0x73,0x52,0xc1,0x99,0x73,0xcf,0x5c,0x09,0xc9,0xd5,0x92,0x41,0x42,0x05,0xc6};
    static std::uint32_t multiplicand89    = 3516861417;
    static std::uint8_t  product89[32]     = {0x09,0x13,0xf8,0x6b,0xad,0x7e,0x6c,0x80,0xfa,0x11,0x63,0xb6,0xcd,0x21,0x26,0x29,0x05,0x0a,0x7f,0x04,0x92,0x78,0x8a,0xe8,0xa1,0xfe,0x19,0xa3,0x77,0x50,0xc3,0x36};
    static std::uint32_t carry89           = 2865340757;
    uint256_from_bytes(multiplier, multiplier89);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand89);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product89, product_data, 32) != 0 && carry89 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier90[32]  = {0x34,0x12,0x88,0x22,0x13,0xf3,0x88,0x70,0x4f,0xec,0x0f,0x40,0x9e,0xfa,0xc2,0x92,0x2f,0x65,0xab,0x4e,0x5f,0x2e,0xe4,0x0d,0xad,0xa6,0x5c,0xc4,0x68,0xb3,0xe3,0xaa};
    static std::uint32_t multiplicand90    = 3415706595;
    static std::uint8_t  product90[32]     = {0x8e,0x45,0x18,0xe3,0x75,0xa6,0x4b,0x51,0x47,0xc8,0x3a,0xd1,0xcf,0xcf,0x7b,0x2b,0x6b,0xde,0xc7,0xac,0x39,0x2b,0xfe,0x1a,0xc5,0xc3,0x4e,0xa5,0x9b,0x66,0x2d,0xbe};
    static std::uint32_t carry90           = 694781269;
    uint256_from_bytes(multiplier, multiplier90);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand90);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product90, product_data, 32) != 0 && carry90 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier91[32]  = {0xb2,0x06,0x1e,0xcc,0x65,0xd4,0x64,0xfd,0x29,0xe7,0x8b,0x06,0xa7,0x2e,0xd5,0x08,0x17,0x55,0xc6,0xde,0x88,0xb4,0x09,0xc8,0xa3,0xa1,0x6d,0x92,0x27,0x90,0xbb,0x01};
    static std::uint32_t multiplicand91    = 1321113728;
    static std::uint8_t  product91[32]     = {0xc8,0x13,0x0d,0x11,0x1c,0xd2,0x75,0xab,0xa4,0x31,0xd0,0x41,0xf9,0x04,0xc6,0x27,0xff,0xc7,0xe1,0x09,0xa4,0x98,0xa6,0xab,0x84,0x4d,0x06,0xf6,0xd0,0x24,0x18,0x80};
    static std::uint32_t carry91           = 918710265;
    uint256_from_bytes(multiplier, multiplier91);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand91);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product91, product_data, 32) != 0 && carry91 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier92[32]  = {0x6a,0x01,0x26,0x0f,0x5b,0x70,0x42,0xdf,0xe2,0x39,0xd3,0xd7,0x91,0x07,0x75,0x6f,0xbe,0xce,0x71,0x45,0x4f,0xf6,0xf2,0xc5,0x0d,0x25,0xf9,0x54,0xf4,0x04,0x2f,0x1e};
    static std::uint32_t multiplicand92    = 3445508768;
    static std::uint8_t  product92[32]     = {0xdb,0x94,0xb2,0xcd,0x6f,0xdb,0xe3,0x31,0x83,0xaa,0xf0,0x6e,0x67,0x6f,0x13,0x81,0x06,0x40,0xf1,0x84,0x4c,0x66,0xed,0x8f,0xc6,0x67,0x56,0xe6,0x0b,0x40,0x1e,0xc0};
    static std::uint32_t carry92           = 1426716364;
    uint256_from_bytes(multiplier, multiplier92);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand92);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product92, product_data, 32) != 0 && carry92 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier93[32]  = {0x01,0x81,0x20,0xf8,0xf1,0x26,0x16,0x42,0x34,0x23,0x88,0x0b,0x67,0xac,0x56,0xf8,0xba,0x60,0x49,0x1e,0x64,0x06,0xf4,0x58,0x32,0x7b,0xcd,0xa3,0xa4,0xfc,0x86,0x21};
    static std::uint32_t multiplicand93    = 3872473880;
    static std::uint8_t  product93[32]     = {0x83,0xa1,0x56,0x8b,0x3a,0x49,0xe7,0x16,0x80,0x64,0x37,0x0a,0x4b,0x6d,0xea,0x65,0xab,0xd7,0xb8,0x3b,0xeb,0xf6,0x6f,0x4f,0x0b,0x41,0xae,0x30,0xb5,0xb8,0x36,0x18};
    static std::uint32_t carry93           = 22756976;
    uint256_from_bytes(multiplier, multiplier93);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand93);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product93, product_data, 32) != 0 && carry93 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier94[32]  = {0x5d,0x5e,0xc1,0xad,0xe2,0x01,0xaa,0xfd,0x93,0xea,0x6a,0x94,0x67,0xfd,0xe1,0xc3,0x17,0x2a,0x39,0x0a,0xd2,0x03,0xac,0xfe,0x1d,0x10,0xe9,0x31,0x6c,0x7b,0x31,0xe2};
    static std::uint32_t multiplicand94    = 3320243759;
    static std::uint8_t  product94[32]     = {0x17,0x8c,0x1e,0x0e,0xc0,0x94,0x80,0x12,0xb9,0x26,0xb3,0x81,0x26,0x8c,0x07,0x75,0xc3,0x55,0xb5,0x18,0xd4,0xc5,0x31,0x69,0x12,0x7f,0x7b,0x9b,0x54,0x7b,0x34,0x7e};
    static std::uint32_t carry94           = 1210982945;
    uint256_from_bytes(multiplier, multiplier94);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand94);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product94, product_data, 32) != 0 && carry94 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier95[32]  = {0xe8,0xe8,0x4b,0x0d,0xce,0x74,0xb3,0xc4,0xa4,0x02,0xbb,0x72,0x24,0x7a,0xab,0xb5,0x8d,0x32,0x3d,0x9e,0x0d,0x3b,0xe8,0xee,0x03,0xcc,0x2f,0x9b,0x21,0x46,0x0c,0x5a};
    static std::uint32_t multiplicand95    = 2166652372;
    static std::uint8_t  product95[32]     = {0xcf,0xfd,0xbc,0x3d,0x52,0xb8,0x53,0xc4,0x08,0x38,0xe8,0x1c,0xbd,0x1c,0x04,0x67,0xc4,0x96,0x40,0x25,0xe7,0xbb,0x89,0xa9,0xb5,0xeb,0x25,0xc9,0xd8,0xb2,0x2c,0x88};
    static std::uint32_t carry95           = 1971208438;
    uint256_from_bytes(multiplier, multiplier95);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand95);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product95, product_data, 32) != 0 && carry95 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier96[32]  = {0x11,0x2d,0x40,0x95,0xec,0xed,0x8d,0xed,0x2b,0xfa,0x1f,0x10,0x85,0x6a,0xab,0x1d,0x29,0x6c,0xb0,0x8c,0x48,0x86,0x05,0x8b,0x59,0x12,0xeb,0x60,0x25,0x58,0xd6,0xc0};
    static std::uint32_t multiplicand96    = 1648128206;
    static std::uint8_t  product96[32]     = {0x26,0x82,0x08,0x4e,0xa3,0xac,0x06,0x9a,0x6b,0xce,0x54,0x2b,0x4b,0x63,0xc4,0xa5,0xf7,0x57,0xbe,0x25,0xa3,0x07,0x8b,0xa3,0xed,0x08,0x3a,0xbc,0xc0,0x70,0xce,0x80};
    static std::uint32_t carry96           = 110584038;
    uint256_from_bytes(multiplier, multiplier96);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand96);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product96, product_data, 32) != 0 && carry96 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier97[32]  = {0x95,0x26,0xe3,0xd0,0x4e,0xe6,0xf4,0xff,0x6b,0x89,0xd4,0x63,0xa6,0x26,0xb0,0x97,0x4e,0x64,0x0c,0xd4,0xc7,0x30,0xa7,0xcb,0xa0,0x85,0xda,0x1f,0xd9,0x58,0xb1,0xe6};
    static std::uint32_t multiplicand97    = 1828538688;
    static std::uint8_t  product97[32]     = {0x66,0xd6,0xc4,0x2f,0x77,0x65,0x82,0x56,0x20,0x99,0x0a,0x06,0xec,0xa1,0xf9,0x78,0x92,0xfd,0x43,0xde,0x67,0xf9,0x1f,0xfc,0x4d,0xd4,0xd4,0xa5,0x79,0x35,0x0f,0x80};
    static std::uint32_t carry97           = 1065351736;
    uint256_from_bytes(multiplier, multiplier97);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand97);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product97, product_data, 32) != 0 && carry97 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier98[32]  = {0x11,0x2e,0xd1,0xdf,0x1b,0x69,0x56,0x7e,0x66,0x7c,0xd6,0x0b,0x79,0x24,0xde,0xde,0xcf,0x7e,0xda,0x11,0x2d,0xf8,0x3c,0x66,0xd6,0x27,0xd2,0xb8,0x75,0x52,0x6e,0x31};
    static std::uint32_t multiplicand98    = 1540068208;
    static std::uint8_t  product98[32]     = {0x21,0xa8,0x1c,0x9f,0xff,0x6a,0x11,0x3a,0x54,0xaf,0x67,0x0b,0x1a,0x8c,0x13,0xbb,0xa5,0xad,0xf6,0x3a,0x1a,0xf5,0x73,0x72,0x39,0x65,0x71,0x9a,0x75,0x31,0x58,0x70};
    static std::uint32_t carry98           = 103370400;
    uint256_from_bytes(multiplier, multiplier98);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand98);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product98, product_data, 32) != 0 && carry98 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
    static std::uint8_t  multiplier99[32]  = {0x0a,0x6f,0xb1,0x54,0xa8,0x37,0x6d,0xcd,0x82,0x99,0xed,0x6e,0x81,0x1c,0x8f,0xa7,0x71,0x24,0xc2,0x05,0xcd,0x62,0x5a,0x7f,0x17,0x7a,0x83,0x34,0x5d,0x86,0x6b,0x34};
    static std::uint32_t multiplicand99    = 2733476194;
    static std::uint8_t  product99[32]     = {0x82,0x7a,0xff,0x3a,0xc2,0xe2,0x54,0x51,0x1b,0xfe,0xa1,0xbe,0xa9,0x6c,0x9b,0x75,0x47,0x3e,0xc2,0x74,0x76,0x98,0xeb,0xaa,0x27,0xc6,0xe5,0x60,0xe3,0xf7,0xdd,0xe8};
    static std::uint32_t carry99           = 111435064;
    uint256_from_bytes(multiplier, multiplier99);
    carry = uint256_mul_carry_uint32(product, multiplier, multiplicand99);
    uint256_to_bytes(product_data, product);
    if (std::memcmp(product99, product_data, 32) != 0 && carry99 != carry)
    {
        throw std::runtime_error("err in common::uint256_mul_carry_uint32");
    }
}
